import { autoTrackerReport } from './actionTracker';
import { hashPageTrackerReport, historyPageTrackerReport } from './pageTracker';
import { errorTrackerReport } from './errorTracker';
import { httpTrackerReport } from './httpTracker';
/**
 * 加载配置
 * @param {*} options 
 */
export function loadConfig(options) {
  const { 
    appId,  // 系统id
    userId, // 用户id
    reportUrl, // 后端url
    autoTracker, // 自动埋点
    delay, // 延迟和合并上报的功能
    hashPage, // 是否hash录有
    errorReport, // 是否开启错误监控
    httpReport, //是否开启网络请求监控
    //例如：code等同于0或者500，或statusCode等于500上报报文 /(?:"code"\s*:\s*(?:0|500|"0"|"500")|"statusCode"\s*:\s*(?:500|"500"))/
    responseRegex,//响应报文符合正则规则时，上报响应报文（对status==200时，符合正则的报文上报）
  } = options;

  // --------- appId ----------------
  if (appId) {
    window['_monitor_app_id_'] = appId;
  }

  // --------- userId ----------------
  if (userId) {
    window['_monitor_user_id_'] = userId;
  }

  // --------- 服务端地址 ----------------
  if (reportUrl) {
    window['_monitor_report_url_'] = reportUrl;
  }

  // -------- 合并上报的间隔 ------------
  if (delay) {
    window['_monitor_delay_'] = delay;
  }

  // --------- 是否开启错误监控 ------------
  if (errorReport) {
    errorTrackerReport();
  }

   // --------- 是否开启网络请求监控 ------------
  if (httpReport) {
    httpTrackerReport(responseRegex);
  }

  // --------- 是否开启无痕埋点 ----------
  if (autoTracker) {
    autoTrackerReport();
  }

  // ----------- 路由监听 --------------
  if (hashPage) {
    hashPageTrackerReport(); // hash路由上报
  } else {
    historyPageTrackerReport(); // history路由上报
  }
}


export const getPathTo = (element) => {
  if (element.id !== '')
    return '//*[@id="' + element.id + '"]';
  if (element === document.body)
    return element.tagName;

  let ix = 0;
  if (element && element.parentNode && element.parentNode.childNodes) {
    let siblings = element?.parentNode?.childNodes;

    for (let i = 0; i < siblings.length; i++) {
      let sibling = siblings[i];
      if (sibling === element)
        return getPathTo(element.parentNode) + '/' + element.tagName + '[' + (ix + 1) + ']';
      if (sibling.nodeType === 1 && sibling.tagName === element.tagName)
        ix++;
    }
  } else {
    return null
  }

}

export const getPathTo2 = (element) => {
  if (!element) return { node: "", path: "" };

  // 基础结果对象 - 确保node永远有值
  const result = {
    node: element.nodeName,
    path: "",
    className: element.className // 直接获取元素自身的类名
  };

  // 添加元素特定属性
  if (element.tagName === "BUTTON") {
    // 获取按钮的文本内容（包括所有子元素）
    result.textContent = element.textContent || "";
    // return result
  } else if (element.tagName === "IMG") {
    const img = element;
    result.src = "";
    
    result.alt = img.alt || "";
  }


  // 处理有ID的元素
  if (element.id) {
    return {
      ...result,
      path: `//*[@id="${element.id}"]`
    };
  }

  // 处理body元素
  if (element === document.body) {
    return {
      ...result,
      path: "BODY"
    };
  }

  // 处理html元素
  if (element === document.documentElement) {
    return {
      ...result,
      path: "HTML"
    };
  }

  // 没有父元素的情况
  if (!element.parentElement) {
    return {
      ...result,
      path: element.tagName
    };
  }


  // 只考虑元素节点 (Node.ELEMENT_NODE)
  const siblings = Array.from(element.parentElement.children).filter(
    sibling => sibling.nodeType === Node.ELEMENT_NODE
  );

  for (let i = 0; i < siblings.length; i++) {
    const sibling = siblings[i];

    if (sibling === element) {
      // found = true;
      // 递归获取父元素路径

      const parentResult = getPathTo(element.parentElement);
      if (!parentResult) {
        return result
      }
      const tagName = element.tagName;

      // 计算相同类型元素的位置
      let sameTypeIndex = 1;
      for (let j = 0; j < i; j++) {
        if (siblings[j].tagName === element.tagName) {
          sameTypeIndex++;
        }
      }
      const path = parentResult?.path || parentResult
      if (path.includes('BUTTON')) {
        const textContent = element.textContent;
        return {
          ...result,
          textContent,
          node: 'BUTTON',
          // 路径格式: 父路径/标签名[相同类型索引]
          path: `${path}/${tagName}[${sameTypeIndex}]`
        };
      } else {
        const src = element.src
        return {
          ...result,
          src,
          // 路径格式: 父路径/标签名[相同类型索引]
          path: `${path}/${tagName}[${sameTypeIndex}]`
        };
      }
    }
  }

  // 如果没有找到元素（理论上不应该发生）
  return {
    ...result,
    path: element.tagNames
  };
};
 export const getImgButtonPath = (element)=>{
   const data = getPathTo2(element)
   if(data.path && (data.path.includes('IMG')||data.path.includes('BUTTON'))){
    if (data.src) {
      data.src = data.src.substring(0, 100);
    }
    return data
   }else{
    return null
   }
}